/** 
 * @main	Plik naglowkowy regulatorow
 * @file    regulatory.h
 * @author  Grzegorz Sejnota
 *
 * @created on 1 marca 2009, 10:41
 * @version 0.0001
 */


#ifndef _REGULATORY_H
#define	_REGULATORY_H

#include "dyskretny.h"
#include "generatory.h"
#include "macierz.h"
#include "identyfikacja.h"
#include <string>
#include <vector>

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++ POCZ�TEK [interfejsu Regulator] +++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/**
 * Klasa wirtualna (interfejs) regulatorow dziedziczaca z klasy ObiektDyskretny. 
 * Implementuje ogolne metody sluzace do 
 * generowania wartosci zadanej, ktora moze byc zlozeniem wielu sygnalow 
 * udostepnianych w ramach generatorow z "generatory.h". Regulator realizuje takze
 * ujemne sprzezenie zwrotne - wejsciem jest wartoscRegulowana, ktora jest odejmowana
 * od wartosciZadanej generowanej w wewnatrz regulatora.
 */
class Regulator : public ObiektDyskretny {
protected:
    ///wartosc zadana ustawiana w regulatorze
    double wartoscZadana;

    ///uchyb - roznica pomiedzy wartoscZadana i wartoscRegulowana
    double uchyb;

    ///sterowanie - wyjscie z regulatora 
    double sterowanie;

    ///wartosc regulowana - pomiar wyjscia regulowanego obiektu
    double wartoscRegulowana;

    ///wektor wskaznikow do obiektow klasy generator
    std::vector<Generator* > generatory;

    ///nazwa regulatora
    std::string nazwa;

public:

    //======= funkcja wirtualna pobierzWartoscZadana ===========================
    /**
     * Funkcja inpspektor zwracajaca wartoscZadana
     *      @return wartosc zadana
     */
    virtual double pobierzWartoscZadana() const {
        return wartoscZadana;
    }

    //======= funkcja wirtualna pobierzUchyb ===================================
    /**
     * Funkcja inpspektor zwracajaca uchyb
     *      @return uchyb
     */
    virtual double pobierzUchyb() const {
        return uchyb;
    }


    //======= funkcja wirtualna pobierzSterowanie ==============================
    /**
     * Funkcja inpspektor zwracajaca sterowanie
     *      @return sterowanie
     */
    virtual double pobierzSterowanie() const {
        return sterowanie;
    }

    //======= funkcja wirtualna pobierzWartoscRegulowana =======================
    /**
     * Funkcja inpspektor zwracajaca wartoscRegulowana
     *      @return wartosc regulowana
     */
    virtual double pobierzWartoscRegulowana() const {
        return wartoscRegulowana;
    }

    //======= funkcja wirtualna pobierzNazwe ===================================
    /**
     * Funkcja pobierajaca nazwe regulatora - implementacja funkji czysto wirtualnej
     * interfejsu ObiektDyskretny.
     *		@return nazwa obiektu
     */
    std::string pobierzNazwe() const {
        return nazwa;
    }

    //======= funkcja wirtualna dodajGenerator =================================
    /*
     * Funkcja dodajaca generator wartosci zadanej.
     */
    virtual void dodajGenerator(Generator *);

    //======= funkcja wirtualna dodajGenerator =================================
    /*
     * Funkcja dodajaca generator wartosci zadanej.
     */
    virtual void dodajGenerator(std::map< std::string, std::string >);


    //======= funkcja wirtualna usunGenerator ==================================
    /*
     * Funkcja usuwajaca generatora wartosci zadanej o podanym numerze.
     *		
     */
    virtual void usunGenerator(int);

     //======= funkcja wirtualna usunGenerator ==================================
    /*
     * Funkcja usuwajaca generatora wartosci zadanej o podanej nazwie.
     *		
     */
   virtual void usunGenerator(std::string);
   
   std::vector<std::string> pokazUstawioneGeneratory();
   
    std::map<std::string,std::string> pokazParametryGeneratora(std::string);
   
   std::vector<Generator*>::iterator Regulator::znajdzGenerator(std::string);

   void zmienParametryGeneratora(std::string, std::map<std::string,std::string>);
      
      
    //======= funkcja wirtualna zerujPamiec ====================================
    /**
     * Zeruje pamiec regulatora - impelementacja funkcji czysto wirtualnej interfejsu
     * ObiektDyskretny. Wywoluje metode resetGeneratorow. W wypadku impelementacji 
     * regulatora pamietajacego poprzednie stany obiektu np. PID nalezy przyslonic
     * te metode wersja zapewniajaca czyszczenie pamieci regulatora.
     */
    void Regulator::zerujPamiec();

    //======= funkcja zmierzWyjscie ============================================
    /**
     * Funkcja probkujaca Regulator. Funkcja symuluje dzialanie czujnika pomiarowego
     * - pobiera wartosc wyjscia obiektu w kolejnej chwili czasu - przyszlej probce 
     * przy zalozeniu braku zmiany sterowania.
     *      @return przyszle wyjscie z obiektu
     */
    double zmierzWyjscie();

protected:
    //======= funkcja wirtualna reset ==========================================
    /*
     * Funkcja resetujaca - rozpoczyna generacje od poczatku.
     */
    virtual void resetGeneratorow();
};
//------------------------------------------------------------------------------
//-------------- KONIEC [interfejsu Regulator] ---------------------------------
//------------------------------------------------------------------------------



//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++ POCZATEK [klasy RegulatorP] +++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/**
 * Klasa reprezentujaca regulator typu P - proporcjonalny. Klasa impelementuje interfejs
 * Regulator.
 */
class RegulatorP : public Regulator {
protected:
    ///wzmocnienie regulatora
    double wzmocnienie;

    ///liczba regulatorow P
    static int liczbaRegulatorowP;

    static std::vector<std::string> inicjalizujKlucze();

    /// statyczny wzorzec mapy konfiguracji
    static std::vector< std::string > kluczeMapy;

public:
    /* konstruktor */
    RegulatorP(double);

    /* konstruktor kopiujacy */
    RegulatorP(const RegulatorP &);

    /* destruktor */
    ~RegulatorP();

    /* implementacja funkcji symuluj interfejsu ObiektDyskretny */
    double symuluj(double);

    /* implementacja funckji zmierzWyjscie interfejsu ObiektDyskretny */
    double zmierzWyjscie();

    /* implementacja funkcji ustawParametry interfejsu ObiektDyskretny */
    bool ustawParametry(std::map<std::string, std::string>);

    /* pobieranie mapy parametrow */
    std::map<std::string, std::string> pobierzParametry() const;

	/* implementacja funkcji zerujPamiec interfejsu ObiektDyskretny */
    void zerujPamiec();

    /* implementacja funkcji wypiszInfo interfejsu ObiektDyskretny */
    void wypiszInfo() const;
};
//------------------------------------------------------------------------------
//-------------- KONIEC [klasy RegulatorP] -------------------------------------
//------------------------------------------------------------------------------

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++ POCZATEK [klasy RegulatorPID] +++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/**
 * Klasa reprezentujaca regulator typu PID - proporcjonalno-calkujaco-roniczkujacy. 
 * Klasa impelementuje interfejs Regulator.
 */
class RegulatorPID : public Regulator {
protected:
    ///wzmocnienie regulatora
    double k;

    ///czas calkowania
    double Ti;

    //czas rozniczkowania
    double Td;

    //parametr filtru rozniczkowania Td/N
    double N;

    //wartosc calki
    double czescI;

    //wartosc rozniczki
    double czescD;

    //parametr b czesci proporcjonalnej
    double b;

    static std::vector<std::string> inicjalizujKlucze();

    /// statyczny wzorzec mapy konfiguracji
    static std::vector< std::string > kluczeMapy;

private:
    ///liczba regulatorow PID
    static int liczbaRegulatorowPID;

public:
    /* konstruktor */
    RegulatorPID(double);

    /* konstruktor kopiujacy */
    RegulatorPID(const RegulatorPID &);

    /* destruktor */
    ~RegulatorPID();

    /* implementacja funkcji symuluj interfejsu ObiektDyskretny */
    double symuluj(double);

    /* implementacja funckji zmierzWyjscie interfejsu ObiektDyskretny */
    double zmierzWyjscie();

    /* implementacja funkcji ustawParametry interfejsu ObiektDyskretny */
    bool ustawParametry(std::map<std::string, std::string>);

    /* pobieranie mapy parametrow */
    std::map<std::string, std::string> pobierzParametry() const;

    /* implementacja funkcji zerujPamiec interfejsu ObiektDyskretny */
    void zerujPamiec();

    /* implementacja funkcji wypiszInfo interfejsu ObiektDyskretny */
    void wypiszInfo() const;

};
//------------------------------------------------------------------------------
//-------------- KONIEC [klasy RegulatorPID] -----------------------------------
//------------------------------------------------------------------------------

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++ POCZATEK [klasy RegulatorGPC] +++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

/**
 * Klasa reprezentujaca regulator typu GPC - uogolniony regulator predykcyjny. 
 * Klasa impelementuje interfejs Regulator.
 */
class RegulatorGPC : public Regulator {
protected:
    // ---------- parametry strojenia ------------------------------------------
    ///horyzont predykcji
    int H;

    ///horyzont sterowania
    int L;

    ///waga dla sterowania
    double ro;

    ///parametr trajektorii odniesienia
    double alfa;
    
    ///obiekt identyfikacyjny
    Identyfikacja ident;
    
    /// stopien identyfikowanego wielomianu A 
    int dA;
    
    /// stopien identyfikowanego wielomianu B 
    int dB;
    
    /// opoznienie identyfikownaego obiektu
    int k;

    // ---------- zmienne pomocnicze -------------------------------------------
    ///macierz Q
    Macierz macierzQ;

    ///wektor q
    Macierz wektorQ;

    ///wektor trajektorii odniesienia w0
    Macierz wektorW0;

    ///wektor odpowiedzi swobodnej y0
    Macierz wektorY0;
    
    ///wektor wspolczynnikow obiektu A
    std::vector<double> wspA;
    
    ///wektor wspolczynnikow obiektu B
    std::vector<double> wspB;
    
    ///pamiec wyjsc obiektu
    std::deque<double> pamiecY;
    
    ///pamiec wejsc obiektu
    std::deque<double> pamiecU;
    
    /// --------- pola klasy regulator -----------------------------------------
    ///liczba regulatorow GPC
    static int liczbaRegulatorowGPC;

    static std::vector<std::string> inicjalizujKlucze();

    /// statyczny wzorzec mapy konfiguracji
    static std::vector< std::string > kluczeMapy;
    
    /// --------- metody pomocnicze --------------------------------------------
    ///metoda obliczajaca odpowiedz skokowa B/A
    void wyznaczMacierzQ();
    
    ///metoda wyznaczajaca trajektorie odniesienia
    void wyznaczTrajektorieOdniesienia();
    
    ///metoda wyznaczajaca odpowiedz swobodna
    void wyznaczOdpowiedzSwobodna();

public:
    /* konstruktor */
    RegulatorGPC();

    /* konstruktor z parametrami */
    RegulatorGPC(int, int, double, double, int=3, int=3, int=1);

    /* konstruktor kopiujacy */
    RegulatorGPC(const RegulatorGPC &);

    /* destruktor */
    ~RegulatorGPC();

    /* implementacja funkcji symuluj interfejsu ObiektDyskretny */
    double symuluj(double);

    /* implementacja funckji zmierzWyjscie interfejsu ObiektDyskretny */
    double zmierzWyjscie();
    
    /* pobieranie zidentyfikowanych wsp wielomianu A */
    std::vector<double> pobierzWspA() const;
    
    /* pobieranie zidentyfikowanych wsp wielomianu B */
    std::vector<double> pobierzWspB() const;

    /* implementacja funkcji ustawParametry interfejsu ObiektDyskretny */
    bool ustawParametry(std::map<std::string, std::string>);
    
    /* funkcja ustawiajaca horyzont predykcji H */
    void ustawH (int);
    
    /* funkcja ustawiajaca horyzont predykcji L */
    void ustawL (int);
    
    /* funkcja ustawiajaca alfe */
    void ustawAlfa (double);
    
    /* funkcja ustawiajaca parametr ro */
    void ustawRo (double);

    /* pobieranie mapy parametrow */
    std::map<std::string, std::string> pobierzParametry() const;

    /* implementacja funkcji zerujPamiec interfejsu ObiektDyskretny */
    void zerujPamiec();

    /* implementacja funkcji wypiszInfo interfejsu ObiektDyskretny */
    void wypiszInfo() const;
};
//------------------------------------------------------------------------------
//-------------- KONIEC [klasy RegulatorGPC] -----------------------------------
//------------------------------------------------------------------------------

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++ POCZATEK [klasy PrzekaznikH] +++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/**
 * Klasa reprezentujaca regulator typu PrzekaznikH. 
 * Klasa impelementuje interfejs Regulator.
 */
class PrzekaznikH : public Regulator {
protected:
	///flaga oznaczajaca stan przekaznik (true jezeli jest wlaczony - positive)
	bool flagaPrzekaznikPositive;

    ///liczba przekaznikow z histerezą
    static int liczbaPrzekaznikowH;

    static std::vector<std::string> inicjalizujKlucze();

    /// statyczny wzorzec mapy konfiguracji
    static std::vector< std::string > kluczeMapy;

public:
	/// wartosc wzmocnienia przy przekazniku wlaczonym
    double d;

    ///szerokosc histerezy
    double eps;

    /* konstruktor */
    PrzekaznikH(double);

    /* konstruktor kopiujacy */
    PrzekaznikH(const PrzekaznikH &);

    /* destruktor */
    ~PrzekaznikH();

    /* implementacja funkcji symuluj interfejsu ObiektDyskretny */
    double symuluj(double);

    /* implementacja funckji zmierzWyjscie interfejsu ObiektDyskretny */
    double zmierzWyjscie();

    /* implementacja funkcji ustawParametry interfejsu ObiektDyskretny */
    bool ustawParametry(std::map<std::string, std::string>);

    /* pobieranie mapy parametrow */
    std::map<std::string, std::string> pobierzParametry() const;

    /* implementacja funkcji zerujPamiec interfejsu ObiektDyskretny */
    void zerujPamiec();

    /* implementacja funkcji wypiszInfo interfejsu ObiektDyskretny */
    void wypiszInfo() const;
};
//------------------------------------------------------------------------------
//-------------- KONIEC [klasy PrzekaznikH] -----------------------------------
//------------------------------------------------------------------------------

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++ POCZATEK [klasy RegulatorPIDAdapt] +++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/**
 * Klasa reprezentujaca regulator typu PID Adaptacyjny - proporcjonalno-calkujaco-roniczkujacy. 
 * Klasa impelementuje interfejs Regulator.
 */
class RegulatorPIDAdapt : public Regulator {

protected:
    ///wzmocnienie regulatora
    double k;

    ///czas calkowania
    double Ti;

    //czas rozniczkowania
    double Td;

    //parametr filtru rozniczkowania Td/N
    double N;

    //wartosc calki
    double czescI;

    //wartosc rozniczki
    double czescD;

    //parametr b czesci proporcjonalnej
    double b;

    //flaga informujaca o aktywnym samonastrajaniu regulatora
    bool flagaSamonastrajania;

	bool flagaKoniecSamonastrajania;

	//obiekt klasy PrzekaznikH
	PrzekaznikH przekaznikExp;

    ///liczba regulatorow PID
    static int liczbaRegulatorowPIDAdapt;

    static std::vector<std::string> inicjalizujKlucze();

    /// statyczny wzorzec mapy konfiguracji
    static std::vector< std::string > kluczeMapy;


public:
    /* konstruktor */
    RegulatorPIDAdapt(double);

    /* konstruktor kopiujacy */
    RegulatorPIDAdapt(const RegulatorPIDAdapt &);

    /* destruktor */
    ~RegulatorPIDAdapt();

	/* samonastrajanie */
	void samonastrajanie();

    /* implementacja funkcji symuluj interfejsu ObiektDyskretny */
    double symuluj(double);

    /* implementacja funckji zmierzWyjscie interfejsu ObiektDyskretny */
    double zmierzWyjscie();

    /* implementacja funkcji ustawParametry interfejsu ObiektDyskretny */
    bool ustawParametry(std::map<std::string, std::string>);

    /* pobieranie mapy parametrow */
    std::map<std::string, std::string> pobierzParametry() const;

    /* implementacja funkcji zerujPamiec interfejsu ObiektDyskretny */
    void zerujPamiec();

    /* implementacja funkcji wypiszInfo interfejsu ObiektDyskretny */
    void wypiszInfo() const;

	/* Inspektor dla przekaźnika */
    PrzekaznikH* pobierzPrzekaznikH();

	/* Inspektor dla przekaźnika */
    bool czySamonastrajanie() const;	

	void ustawSamonastrajanie(bool wartosc);

	bool czyKoniecSamonastrajania();


};
//------------------------------------------------------------------------------
//-------------- KONIEC [klasy RegulatorPIDAdapt] -----------------------------------
//------------------------------------------------------------------------------

#endif	/* _REGULATORY_H */
